﻿#define _CRT_SECURE_NO_WARNINGS 1
#pragma warning(disable : 6031)
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//括号匹配问题	用栈实现
//bool isValid(char* s) 
//{
//    st st;
//    stinit(&st);
//    while (*s)
//    {
//        if (*s == '('
//            || *s == '{'
//            || *s == '[')
//        {
//            stpush(&st, *s);
//        }
//        else
//        {
//            if (stempty(&st))
//            {
//                stdestroy(&st);
//                return false;
//            }
//            char new = sttop(&st);
//            stpop(&st);
//            if ((*s == ')' && new != '(')
//                || (*s == '}' && new != '{')
//                || (*s == ']' && new != '['))
//            {
//                stdestroy(&st);
//                return false;
//            }
//        }
//        s++;
//    }
//    bool ret = stempty(&st);
//    stdestroy(&st);
//    return ret;
//}
//
//void test2()
//{
//    char s[] = "([)]";
//    bool ret = isValid(s);
//    if (isValid(s) == true)
//    {
//        printf("true");
//    }
//    else
//    {
//        printf("flase");
//    }
//}

//2队列实现栈  队列实现
//typedef struct {
//    Queue q1;
//    Queue q2;
//} MyStack;
//
//
//MyStack* myStackCreate() {
//    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
//    if (!obj)
//    {
//        return NULL;
//    }
//
//    queueinit(&obj->q1);
//    queueinit(&obj->q2);
//
//    return obj;
//}
//
//void myStackPush(MyStack* obj, int x) {
//    if (!queueempty(&obj->q1))
//    {
//        queuepush(&obj->q1, x);
//    }
//    else
//    {
//        queuepush(&obj->q2, x);
//    }
//}
//
//int myStackPop(MyStack* obj) {
//    Queue* noempty = &obj->q1;
//    Queue* empty = &obj->q2;
//    if (queueempty(&obj->q1))
//    {
//        noempty = &obj->q2;
//        empty = &obj->q1;
//    }
//    while (queuesize(noempty) > 1)
//    {
//        queuepush(empty, queuefront(noempty));
//        queuepop(noempty);
//    }
//    int top = queuefront(noempty);
//    queuepop(noempty);
//    return top;
//}
//
//int myStackTop(MyStack* obj) {
//    Queue* noempty = &obj->q1;
//    Queue* empty = &obj->q2;
//    if (queueempty(&obj->q1))
//    {
//        noempty = &obj->q2;
//        empty = &obj->q1;
//    }
//    return queueback(noempty);
//}
//
//
//bool myStackEmpty(MyStack* obj) {
//    return queueempty(&obj->q1)
//        && queueempty(&obj->q2);
//}
//
//void myStackFree(MyStack* obj) {
//    queuedestroy(&obj->q1);
//    queuedestroy(&obj->q2);
//
//    free(obj);
//}


//2栈实现队列 用栈实现
//typedef struct {
//    st pushst;
//    st popst;
//} MyQueue;
//
//
//MyQueue* myQueueCreate() {
//    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
//    if (!obj)
//    {
//        return NULL;
//    }
//
//    stinit(&obj->pushst);
//    stinit(&obj->popst);
//    return obj;
//}
//
//void myQueuePush(MyQueue* obj, int x) {
//    stpush(&obj->pushst, x);
//}
//
//int myQueuePop(MyQueue* obj) {
//    int top = myQueuePeek(obj);
//    stpop(&obj->popst);
//    return top;
//}
//
//int myQueuePeek(MyQueue* obj) {
//    if (stempty(&obj->popst))
//    {
//        while (!stempty(&obj->pushst))
//        {
//            stpush(&obj->popst, sttop(&obj->pushst));
//            stpop(&obj->pushst);
//        }
//    }
//
//    return sttop(&obj->popst);
//}
//
//bool myQueueEmpty(MyQueue* obj) {
//    return stempty(&obj->popst) && stempty(&obj->pushst);
//}
//
//void myQueueFree(MyQueue* obj) {
//    stdestroy(&obj->popst);
//    stdestroy(&obj->pushst);
//    free(obj);
//}

////循环队列
//typedef struct {
//    int front;
//    int rear;
//    int k;
//    int* arr;
//} MyCircularQueue;
//
//
//MyCircularQueue* myCircularQueueCreate(int k) {
//    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
//    if (!obj)
//        return NULL;
//    int* p = (int*)malloc(sizeof(int) * (k + 1));
//    if (!p)
//        return NULL;
//    obj->front = obj->rear = 0;
//    obj->k = k;
//    obj->arr = p;
//    return obj;
//}
//
//bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
//    return obj->rear == obj->front;
//}
//
//bool myCircularQueueIsFull(MyCircularQueue* obj) {
//    return (obj->rear + 1) % (obj->k + 1) == obj->front;
//}
//
//
//bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
//    if (myCircularQueueIsFull(obj))
//        return false;
//
//    obj->arr[obj->rear] = value;
//    obj->rear++;
//    obj->rear %= (obj->k + 1);
//    return true;
//}
//
//bool myCircularQueueDeQueue(MyCircularQueue* obj) {
//    if (myCircularQueueIsEmpty(obj))
//        return false;
//
//    obj->front++;
//    obj->front %= (obj->k + 1);
//    return true;
//}
//
//int myCircularQueueFront(MyCircularQueue* obj) {
//    if (myCircularQueueIsEmpty(obj))
//        return -1;
//
//    return obj->arr[obj->front];
//}
//
//int myCircularQueueRear(MyCircularQueue* obj) {
//    if (myCircularQueueIsEmpty(obj))
//        return -1;
//
//    return obj->arr[(obj->rear - 1 + obj->k + 1) % (obj->k + 1)];
//}
//
//void myCircularQueueFree(MyCircularQueue* obj) {
//    free(obj->arr);
//    free(obj);
//}
//
